package gti310.tp4;

import java.util.ArrayList;

/**
 * La classe zigzag contient les méthodes pour changer l’ordre des coefficients 
 * pour rendre le codage plus efficace. 
 * 
 * @author Émile Robinson
 * @date 2014-12-06
 *
 */
public class zigzag {	

	public int zigZag[][] = new int[64][2];	
	private ListeComposant liste;

	/**
	 * Constructeur de la classe zigzag, reçoit en paramètre la liste des
	 * composant de couleur et initialise la matrice zigZag. 
	 * 
	 * @param liste
	 */
	public zigzag(ListeComposant liste)	{
		this.liste = liste;

		zigZag[0][0] = 0; // 0,0
		zigZag[0][1] = 0;
		zigZag[1][0] = 0; // 0,1
		zigZag[1][1] = 1;
		zigZag[2][0] = 1; // 1,0
		zigZag[2][1] = 0;
		zigZag[3][0] = 2; // 2,0
		zigZag[3][1] = 0;
		zigZag[4][0] = 1; // 1,1
		zigZag[4][1] = 1;
		zigZag[5][0] = 0; // 0,2
		zigZag[5][1] = 2;
		zigZag[6][0] = 0; // 0,3
		zigZag[6][1] = 3;
		zigZag[7][0] = 1; // 1,2
		zigZag[7][1] = 2;
		zigZag[8][0] = 2; // 2,1
		zigZag[8][1] = 1;
		zigZag[9][0] = 3; // 3,0
		zigZag[9][1] = 0;
		zigZag[10][0] = 4; // 4,0
		zigZag[10][1] = 0;
		zigZag[11][0] = 3; // 3,1
		zigZag[11][1] = 1;
		zigZag[12][0] = 2; // 2,2
		zigZag[12][1] = 2;
		zigZag[13][0] = 1; // 1,3
		zigZag[13][1] = 3;
		zigZag[14][0] = 0; // 0,4
		zigZag[14][1] = 4;
		zigZag[15][0] = 0; // 0,5
		zigZag[15][1] = 5;
		zigZag[16][0] = 1; // 1,4
		zigZag[16][1] = 4;
		zigZag[17][0] = 2; // 2,3
		zigZag[17][1] = 3;
		zigZag[18][0] = 3; // 3,2
		zigZag[18][1] = 2;
		zigZag[19][0] = 4; // 4,1
		zigZag[19][1] = 1;
		zigZag[20][0] = 5; // 5,0
		zigZag[20][1] = 0;
		zigZag[21][0] = 6; // 6,0
		zigZag[21][1] = 0;
		zigZag[22][0] = 5; // 5,1
		zigZag[22][1] = 1;
		zigZag[23][0] = 4; // 4,2
		zigZag[23][1] = 2;
		zigZag[24][0] = 3; // 3,3
		zigZag[24][1] = 3;
		zigZag[25][0] = 2; // 2,4
		zigZag[25][1] = 4;
		zigZag[26][0] = 1; // 1,5
		zigZag[26][1] = 5;
		zigZag[27][0] = 0; // 0,6
		zigZag[27][1] = 6;
		zigZag[28][0] = 0; // 0,7
		zigZag[28][1] = 7;
		zigZag[29][0] = 1; // 1,6
		zigZag[29][1] = 6;
		zigZag[30][0] = 2; // 2,5
		zigZag[30][1] = 5;
		zigZag[31][0] = 3; // 3,4
		zigZag[31][1] = 4;
		zigZag[32][0] = 4; // 4,3
		zigZag[32][1] = 3;
		zigZag[33][0] = 5; // 5,2
		zigZag[33][1] = 2;
		zigZag[34][0] = 6; // 6,1
		zigZag[34][1] = 1;
		zigZag[35][0] = 7; // 7,0
		zigZag[35][1] = 0;
		zigZag[36][0] = 7; // 7,1
		zigZag[36][1] = 1;
		zigZag[37][0] = 6; // 6,2
		zigZag[37][1] = 2;
		zigZag[38][0] = 5; // 5,3
		zigZag[38][1] = 3;
		zigZag[39][0] = 4; // 4,4
		zigZag[39][1] = 4;
		zigZag[40][0] = 3; // 3,5
		zigZag[40][1] = 5;
		zigZag[41][0] = 2; // 2,6
		zigZag[41][1] = 6;
		zigZag[42][0] = 1; // 1,7
		zigZag[42][1] = 7;
		zigZag[43][0] = 2; // 2,7
		zigZag[43][1] = 7;
		zigZag[44][0] = 3; // 3,6
		zigZag[44][1] = 6;
		zigZag[45][0] = 4; // 4,5
		zigZag[45][1] = 5;
		zigZag[46][0] = 5; // 5,4
		zigZag[46][1] = 4;
		zigZag[47][0] = 6; // 6,3
		zigZag[47][1] = 3;
		zigZag[48][0] = 7; // 7,2
		zigZag[48][1] = 2;
		zigZag[49][0] = 7; // 7,3
		zigZag[49][1] = 3;
		zigZag[50][0] = 6; // 6,4
		zigZag[50][1] = 4;
		zigZag[51][0] = 5; // 5,5
		zigZag[51][1] = 5;
		zigZag[52][0] = 4; // 4,6
		zigZag[52][1] = 6;
		zigZag[53][0] = 3; // 3,7
		zigZag[53][1] = 7;
		zigZag[54][0] = 4; // 4,7
		zigZag[54][1] = 7;
		zigZag[55][0] = 5; // 5,6
		zigZag[55][1] = 6;
		zigZag[56][0] = 6; // 6,5
		zigZag[56][1] = 5;
		zigZag[57][0] = 7; // 7,4
		zigZag[57][1] = 4;
		zigZag[58][0] = 7; // 7,5
		zigZag[58][1] = 5;
		zigZag[59][0] = 6; // 6,6
		zigZag[59][1] = 6;
		zigZag[60][0] = 5; // 5,7
		zigZag[60][1] = 7;
		zigZag[61][0] = 6; // 6,7
		zigZag[61][1] = 7;
		zigZag[62][0] = 7; // 7,6
		zigZag[62][1] = 6;
		zigZag[63][0] = 7; // 7,7
		zigZag[63][1] = 7;
	}

	/**
	 * Fait appel aux méthode de processus de Zigzag en parcourant tous les 
	 * bloc 8x8 des composants.
	 * 
	 */
	public void executerZigZag(){
		double[] temp = new double [64];

		//Application de la ZigZag sur tous les bloc de 8x8 de chacune des composantes YCbCr
		for(int i=0; i<liste.getTaille(); i++){
			ArrayList<double[]> zzlist = new ArrayList<double[]>();

			for(int j=0; j<liste.getComponent(i).size(); j++){

				//Application de la DCT sur chacun des bloc 8x8 du component actuel
				temp = applyMatrice(liste.getComponent(i).get(j));
				zzlist.add(temp);
			}//Fin du parcours des 1024 bloc de 8x8

			liste.getZZList().add(zzlist);

		}//Fin du parcours des trois components
	}

	/**
	 * La méthode reçoit une matrice quantifié appliquele processus de ZigZag
	 * et retourne la matrice résultante. 
	 * 
	 * @param tableQuantif
	 * @return
	 */
	private double[] applyMatrice (double [][] tableQuantif){
		double[] buffer = new double[64];			
		for (int i = 0; i < 64; i++) {
			int row = zigZag[i][0];
			int col = zigZag[i][1];
			double result = tableQuantif[row][col];

			buffer[i] = result;
		}	    
		return (buffer);		
	}

	/**
	 * Retourne la matrice quantifié, soit l'étape avant le ZigZag
	 * 
	 * @param tabZZ
	 * @return buffer, la matrice quantifié
	 */
	public double[][] inverseZigZag(double[] tabZZ){
		double[][] buffer = new double[8][8];

		for(int i=0; i < 64;i++) {
			int row = zigZag[i][0];
			int col = zigZag[i][1];
			double result = tabZZ[i];

			buffer[row][col] = result;            
		}	    
		return (buffer);
	}


}
